home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / markupbase.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  391 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Shared support for scanning document type declarations in HTML and XHTML.
  5.  
  6. This module is used as a foundation for the HTMLParser and sgmllib
  7. modules (indirectly, for htmllib as well).  It has no documented
  8. public API and should not be used directly.
  9.  
  10. '''
  11. import re
  12. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  13. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  14. _commentclose = re.compile('--\\s*>')
  15. _markedsectionclose = re.compile(']\\s*]\\s*>')
  16. _msmarkedsectionclose = re.compile(']\\s*>')
  17. del re
  18.  
  19. class ParserBase:
  20.     '''Parser base class which provides some common support methods used
  21.     by the SGML/HTML and XHTML parsers.'''
  22.     
  23.     def __init__(self):
  24.         if self.__class__ is ParserBase:
  25.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  26.         
  27.  
  28.     
  29.     def error(self, message):
  30.         raise NotImplementedError('subclasses of ParserBase must override error()')
  31.  
  32.     
  33.     def reset(self):
  34.         self.lineno = 1
  35.         self.offset = 0
  36.  
  37.     
  38.     def getpos(self):
  39.         '''Return current line number and offset.'''
  40.         return (self.lineno, self.offset)
  41.  
  42.     
  43.     def updatepos(self, i, j):
  44.         if i >= j:
  45.             return j
  46.         
  47.         rawdata = self.rawdata
  48.         nlines = rawdata.count('\n', i, j)
  49.         if nlines:
  50.             self.lineno = self.lineno + nlines
  51.             pos = rawdata.rindex('\n', i, j)
  52.             self.offset = j - pos + 1
  53.         else:
  54.             self.offset = self.offset + j - i
  55.         return j
  56.  
  57.     _decl_otherchars = ''
  58.     
  59.     def parse_declaration(self, i):
  60.         rawdata = self.rawdata
  61.         j = i + 2
  62.         if rawdata[j:j + 1] in ('-', ''):
  63.             return -1
  64.         
  65.         n = len(rawdata)
  66.         if rawdata[j:j + 1] == '--':
  67.             return self.parse_comment(i)
  68.         elif rawdata[j] == '[':
  69.             return self.parse_marked_section(i)
  70.         else:
  71.             (decltype, j) = self._scan_name(j, i)
  72.         if j < 0:
  73.             return j
  74.         
  75.         if decltype == 'doctype':
  76.             self._decl_otherchars = ''
  77.         
  78.         while j < n:
  79.             c = rawdata[j]
  80.             if c == '>':
  81.                 data = rawdata[i + 2:j]
  82.                 if decltype == 'doctype':
  83.                     self.handle_decl(data)
  84.                 else:
  85.                     self.unknown_decl(data)
  86.                 return j + 1
  87.             
  88.             if c in '"\'':
  89.                 m = _declstringlit_match(rawdata, j)
  90.                 if not m:
  91.                     return -1
  92.                 
  93.                 j = m.end()
  94.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  95.                 (name, j) = self._scan_name(j, i)
  96.             elif c in self._decl_otherchars:
  97.                 j = j + 1
  98.             elif c == '[':
  99.                 if decltype == 'doctype':
  100.                     j = self._parse_doctype_subset(j + 1, i)
  101.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  102.                     self.error("unsupported '[' char in %s declaration" % decltype)
  103.                 else:
  104.                     self.error("unexpected '[' char in declaration")
  105.             else:
  106.                 self.error('unexpected %r char in declaration' % rawdata[j])
  107.             if j < 0:
  108.                 return j
  109.                 continue
  110.         return -1
  111.  
  112.     
  113.     def parse_marked_section(self, i, report = 1):
  114.         rawdata = self.rawdata
  115.         (sectName, j) = self._scan_name(i + 3, i)
  116.         if j < 0:
  117.             return j
  118.         
  119.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  120.             match = _markedsectionclose.search(rawdata, i + 3)
  121.         elif sectName in ('if', 'else', 'endif'):
  122.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  123.         else:
  124.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  125.         if not match:
  126.             return -1
  127.         
  128.         if report:
  129.             j = match.start(0)
  130.             self.unknown_decl(rawdata[i + 3:j])
  131.         
  132.         return match.end(0)
  133.  
  134.     
  135.     def parse_comment(self, i, report = 1):
  136.         rawdata = self.rawdata
  137.         if rawdata[i:i + 4] != '<!--':
  138.             self.error('unexpected call to parse_comment()')
  139.         
  140.         match = _commentclose.search(rawdata, i + 4)
  141.         if not match:
  142.             return -1
  143.         
  144.         if report:
  145.             j = match.start(0)
  146.             self.handle_comment(rawdata[i + 4:j])
  147.         
  148.         return match.end(0)
  149.  
  150.     
  151.     def _parse_doctype_subset(self, i, declstartpos):
  152.         rawdata = self.rawdata
  153.         n = len(rawdata)
  154.         j = i
  155.         while j < n:
  156.             c = rawdata[j]
  157.             if c == '<':
  158.                 s = rawdata[j:j + 2]
  159.                 if s == '<':
  160.                     return -1
  161.                 
  162.                 if s != '<!':
  163.                     self.updatepos(declstartpos, j + 1)
  164.                     self.error('unexpected char in internal subset (in %r)' % s)
  165.                 
  166.                 if j + 2 == n:
  167.                     return -1
  168.                 
  169.                 if j + 4 > n:
  170.                     return -1
  171.                 
  172.                 if rawdata[j:j + 4] == '<!--':
  173.                     j = self.parse_comment(j, report = 0)
  174.                     if j < 0:
  175.                         return j
  176.                         continue
  177.                     continue
  178.                 
  179.                 (name, j) = self._scan_name(j + 2, declstartpos)
  180.                 if j == -1:
  181.                     return -1
  182.                 
  183.                 if name not in ('attlist', 'element', 'entity', 'notation'):
  184.                     self.updatepos(declstartpos, j + 2)
  185.                     self.error('unknown declaration %r in internal subset' % name)
  186.                 
  187.                 meth = getattr(self, '_parse_doctype_' + name)
  188.                 j = meth(j, declstartpos)
  189.                 if j < 0:
  190.                     return j
  191.                 
  192.             j < 0
  193.             if c == '%':
  194.                 if j + 1 == n:
  195.                     return -1
  196.                 
  197.                 (s, j) = self._scan_name(j + 1, declstartpos)
  198.                 if j < 0:
  199.                     return j
  200.                 
  201.                 if rawdata[j] == ';':
  202.                     j = j + 1
  203.                 
  204.             rawdata[j] == ';'
  205.             if c == ']':
  206.                 j = j + 1
  207.                 while j < n and rawdata[j].isspace():
  208.                     j = j + 1
  209.                 if j < n:
  210.                     if rawdata[j] == '>':
  211.                         return j
  212.                     
  213.                     self.updatepos(declstartpos, j)
  214.                     self.error('unexpected char after internal subset')
  215.                 else:
  216.                     return -1
  217.             j < n
  218.             if c.isspace():
  219.                 j = j + 1
  220.                 continue
  221.             self.updatepos(declstartpos, j)
  222.             self.error('unexpected char %r in internal subset' % c)
  223.         return -1
  224.  
  225.     
  226.     def _parse_doctype_element(self, i, declstartpos):
  227.         (name, j) = self._scan_name(i, declstartpos)
  228.         if j == -1:
  229.             return -1
  230.         
  231.         rawdata = self.rawdata
  232.         if '>' in rawdata[j:]:
  233.             return rawdata.find('>', j) + 1
  234.         
  235.         return -1
  236.  
  237.     
  238.     def _parse_doctype_attlist(self, i, declstartpos):
  239.         rawdata = self.rawdata
  240.         (name, j) = self._scan_name(i, declstartpos)
  241.         c = rawdata[j:j + 1]
  242.         if c == '':
  243.             return -1
  244.         
  245.         if c == '>':
  246.             return j + 1
  247.         
  248.         while None:
  249.             (name, j) = self._scan_name(j, declstartpos)
  250.             if j < 0:
  251.                 return j
  252.             
  253.             c = rawdata[j:j + 1]
  254.             if c == '':
  255.                 return -1
  256.             
  257.             if c == '(':
  258.                 if ')' in rawdata[j:]:
  259.                     j = rawdata.find(')', j) + 1
  260.                 else:
  261.                     return -1
  262.                 while rawdata[j:j + 1].isspace():
  263.                     j = j + 1
  264.                 if not rawdata[j:]:
  265.                     return -1
  266.                 
  267.             else:
  268.                 (name, j) = self._scan_name(j, declstartpos)
  269.             c = rawdata[j:j + 1]
  270.             if not c:
  271.                 return -1
  272.             
  273.             if c in '\'"':
  274.                 m = _declstringlit_match(rawdata, j)
  275.                 if m:
  276.                     j = m.end()
  277.                 else:
  278.                     return -1
  279.                 c = rawdata[j:j + 1]
  280.                 if not c:
  281.                     return -1
  282.                 
  283.             
  284.             if c == '#':
  285.                 if rawdata[j:] == '#':
  286.                     return -1
  287.                 
  288.                 (name, j) = self._scan_name(j + 1, declstartpos)
  289.                 if j < 0:
  290.                     return j
  291.                 
  292.                 c = rawdata[j:j + 1]
  293.                 if not c:
  294.                     return -1
  295.                 
  296.             
  297.             if c == '>':
  298.                 return j + 1
  299.                 continue
  300.  
  301.     
  302.     def _parse_doctype_notation(self, i, declstartpos):
  303.         (name, j) = self._scan_name(i, declstartpos)
  304.         if j < 0:
  305.             return j
  306.         
  307.         rawdata = self.rawdata
  308.         while None:
  309.             c = rawdata[j:j + 1]
  310.             if not c:
  311.                 return -1
  312.             
  313.             if c == '>':
  314.                 return j + 1
  315.             
  316.             if c in '\'"':
  317.                 m = _declstringlit_match(rawdata, j)
  318.                 if not m:
  319.                     return -1
  320.                 
  321.                 j = m.end()
  322.                 continue
  323.             (name, j) = self._scan_name(j, declstartpos)
  324.             if j < 0:
  325.                 return j
  326.                 continue
  327.  
  328.     
  329.     def _parse_doctype_entity(self, i, declstartpos):
  330.         rawdata = self.rawdata
  331.         if rawdata[i:i + 1] == '%':
  332.             j = i + 1
  333.             while None:
  334.                 c = rawdata[j:j + 1]
  335.                 if not c:
  336.                     return -1
  337.                 
  338.                 if c.isspace():
  339.                     j = j + 1
  340.                     continue
  341.                 break
  342.         else:
  343.             j = i
  344.         (name, j) = self._scan_name(j, declstartpos)
  345.         if j < 0:
  346.             return j
  347.         
  348.         while None:
  349.             c = self.rawdata[j:j + 1]
  350.             if not c:
  351.                 return -1
  352.             
  353.             if c in '\'"':
  354.                 m = _declstringlit_match(rawdata, j)
  355.                 if m:
  356.                     j = m.end()
  357.                 else:
  358.                     return -1
  359.             if c == '>':
  360.                 return j + 1
  361.                 continue
  362.             (name, j) = self._scan_name(j, declstartpos)
  363.             if j < 0:
  364.                 return j
  365.                 continue
  366.  
  367.     
  368.     def _scan_name(self, i, declstartpos):
  369.         rawdata = self.rawdata
  370.         n = len(rawdata)
  371.         if i == n:
  372.             return (None, -1)
  373.         
  374.         m = _declname_match(rawdata, i)
  375.         if m:
  376.             s = m.group()
  377.             name = s.strip()
  378.             if i + len(s) == n:
  379.                 return (None, -1)
  380.             
  381.             return (name.lower(), m.end())
  382.         else:
  383.             self.updatepos(declstartpos, i)
  384.             self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  385.  
  386.     
  387.     def unknown_decl(self, data):
  388.         pass
  389.  
  390.  
  391.